package model;

import java.util.List;

import javax.annotation.Resource;

import javax.ejb.SessionContext;
import javax.ejb.Stateless;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

@Stateless(name = "SessionEJB", mappedName = "TallerTSP-Model-SessionEJB")
public class SessionEJBBean implements SessionEJB, SessionEJBLocal {
    @Resource
    SessionContext sessionContext;
    @PersistenceContext(unitName = "Model")
    private EntityManager em;

    public SessionEJBBean() {
    }

    public Object queryByRange(String jpqlStmt, int firstResult, int maxResults) {
        Query query = em.createQuery(jpqlStmt);
        if (firstResult > 0) {
            query = query.setFirstResult(firstResult);
        }
        if (maxResults > 0) {
            query = query.setMaxResults(maxResults);
        }
        return query.getResultList();
    }

    public ServMantenExterna persistServMantenExterna(ServMantenExterna servMantenExterna) {
        em.persist(servMantenExterna);
        return servMantenExterna;
    }

    public ServMantenExterna mergeServMantenExterna(ServMantenExterna servMantenExterna) {
        return em.merge(servMantenExterna);
    }

    public void removeServMantenExterna(ServMantenExterna servMantenExterna) {
        servMantenExterna = em.find(ServMantenExterna.class, servMantenExterna.getIdServExterno());
        em.remove(servMantenExterna);
    }

    /** <code>select o from ServMantenExterna o</code> */
    public List<ServMantenExterna> getServMantenExternaFindAll() {
        return em.createNamedQuery("ServMantenExterna.findAll").getResultList();
    }

    public Modelo persistModelo(Modelo modelo) {
        em.persist(modelo);
        return modelo;
    }

    public Modelo mergeModelo(Modelo modelo) {
        return em.merge(modelo);
    }

    public void removeModelo(Modelo modelo) {
        modelo = em.find(Modelo.class, modelo.getIdModelo());
        em.remove(modelo);
    }

    /** <code>select o from Modelo o</code> */
    public List<Modelo> getModeloFindAll() {
        return em.createNamedQuery("Modelo.findAll").getResultList();
    }

    public Camion persistCamion(Camion camion) {
        em.persist(camion);
        return camion;
    }

    public Camion mergeCamion(Camion camion) {
        return em.merge(camion);
    }

    public void removeCamion(Camion camion) {
        camion = em.find(Camion.class, camion.getPatente());
        em.remove(camion);
    }

    /** <code>select o from Camion o</code> */
    public List<Camion> getCamionFindAll() {
        return em.createNamedQuery("Camion.findAll").getResultList();
    }

    public DetalleMantencion persistDetalleMantencion(DetalleMantencion detalleMantencion) {
        em.persist(detalleMantencion);
        return detalleMantencion;
    }

    public DetalleMantencion mergeDetalleMantencion(DetalleMantencion detalleMantencion) {
        return em.merge(detalleMantencion);
    }

    public void removeDetalleMantencion(DetalleMantencion detalleMantencion) {
        detalleMantencion = em.find(DetalleMantencion.class, detalleMantencion.getIdDetMantencion());
        em.remove(detalleMantencion);
    }

    /** <code>select o from DetalleMantencion o</code> */
    public List<DetalleMantencion> getDetalleMantencionFindAll() {
        return em.createNamedQuery("DetalleMantencion.findAll").getResultList();
    }

    public JefeTaller persistJefeTaller(JefeTaller jefeTaller) {
        em.persist(jefeTaller);
        return jefeTaller;
    }

    public JefeTaller mergeJefeTaller(JefeTaller jefeTaller) {
        return em.merge(jefeTaller);
    }

    public void removeJefeTaller(JefeTaller jefeTaller) {
        jefeTaller = em.find(JefeTaller.class, jefeTaller.getRutJt());
        em.remove(jefeTaller);
    }

    /** <code>select o from JefeTaller o</code> */
    public List<JefeTaller> getJefeTallerFindAll() {
        return em.createNamedQuery("JefeTaller.findAll").getResultList();
    }

    public Carro persistCarro(Carro carro) {
        em.persist(carro);
        return carro;
    }

    public Carro mergeCarro(Carro carro) {
        return em.merge(carro);
    }

    public void removeCarro(Carro carro) {
        carro = em.find(Carro.class, carro.getPatente());
        em.remove(carro);
    }

    /** <code>select o from Carro o</code> */
    public List<Carro> getCarroFindAll() {
        return em.createNamedQuery("Carro.findAll").getResultList();
    }

    public JefeOperaciones persistJefeOperaciones(JefeOperaciones jefeOperaciones) {
        em.persist(jefeOperaciones);
        return jefeOperaciones;
    }

    public JefeOperaciones mergeJefeOperaciones(JefeOperaciones jefeOperaciones) {
        return em.merge(jefeOperaciones);
    }

    public void removeJefeOperaciones(JefeOperaciones jefeOperaciones) {
        jefeOperaciones = em.find(JefeOperaciones.class, jefeOperaciones.getRutJo());
        em.remove(jefeOperaciones);
    }

    /** <code>select o from JefeOperaciones o</code> */
    public List<JefeOperaciones> getJefeOperacionesFindAll() {
        return em.createNamedQuery("JefeOperaciones.findAll").getResultList();
    }

    public InsumoMantencion persistInsumoMantencion(InsumoMantencion insumoMantencion) {
        em.persist(insumoMantencion);
        return insumoMantencion;
    }

    public InsumoMantencion mergeInsumoMantencion(InsumoMantencion insumoMantencion) {
        return em.merge(insumoMantencion);
    }

    public void removeInsumoMantencion(InsumoMantencion insumoMantencion) {
        insumoMantencion =
                em.find(InsumoMantencion.class, new InsumoMantencionPK(insumoMantencion.getIdDetMantencion(),
                                                                       insumoMantencion.getIdInTaller()));
        em.remove(insumoMantencion);
    }

    /** <code>select o from InsumoMantencion o</code> */
    public List<InsumoMantencion> getInsumoMantencionFindAll() {
        return em.createNamedQuery("InsumoMantencion.findAll").getResultList();
    }

    public InsumoTaller persistInsumoTaller(InsumoTaller insumoTaller) {
        em.persist(insumoTaller);
        return insumoTaller;
    }

    public InsumoTaller mergeInsumoTaller(InsumoTaller insumoTaller) {
        return em.merge(insumoTaller);
    }

    public void removeInsumoTaller(InsumoTaller insumoTaller) {
        insumoTaller = em.find(InsumoTaller.class, insumoTaller.getIdInsumosTaller());
        em.remove(insumoTaller);
    }

    /** <code>select o from InsumoTaller o</code> */
    public List<InsumoTaller> getInsumoTallerFindAll() {
        return em.createNamedQuery("InsumoTaller.findAll").getResultList();
    }

    public Conductor persistConductor(Conductor conductor) {
        em.persist(conductor);
        return conductor;
    }

    public Conductor mergeConductor(Conductor conductor) {
        return em.merge(conductor);
    }

    public void removeConductor(Conductor conductor) {
        conductor = em.find(Conductor.class, conductor.getRutC());
        em.remove(conductor);
    }

    /** <code>select o from Conductor o</code> */
    public List<Conductor> getConductorFindAll() {
        return em.createNamedQuery("Conductor.findAll").getResultList();
    }

    public PsTxn persistPsTxn(PsTxn psTxn) {
        em.persist(psTxn);
        return psTxn;
    }

    public PsTxn mergePsTxn(PsTxn psTxn) {
        return em.merge(psTxn);
    }

    public void removePsTxn(PsTxn psTxn) {
        psTxn = em.find(PsTxn.class, new PsTxnPK(psTxn.getCollid(), psTxn.getId()));
        em.remove(psTxn);
    }

    /** <code>select o from PsTxn o</code> */
    public List<PsTxn> getPsTxnFindAll() {
        return em.createNamedQuery("PsTxn.findAll").getResultList();
    }

    public Vehiculo persistVehiculo(Vehiculo vehiculo) {
        em.persist(vehiculo);
        return vehiculo;
    }

    public Vehiculo mergeVehiculo(Vehiculo vehiculo) {
        return em.merge(vehiculo);
    }

    public void removeVehiculo(Vehiculo vehiculo) {
        vehiculo = em.find(Vehiculo.class, vehiculo.getPatente());
        em.remove(vehiculo);
    }

    /** <code>select o from Vehiculo o</code> */
    public List<Vehiculo> getVehiculoFindAll() {
        return em.createNamedQuery("Vehiculo.findAll").getResultList();
    }

    public Personal persistPersonal(Personal personal) {
        em.persist(personal);
        return personal;
    }

    public Personal mergePersonal(Personal personal) {
        return em.merge(personal);
    }

    public void removePersonal(Personal personal) {
        personal = em.find(Personal.class, personal.getRut());
        em.remove(personal);
    }

    /** <code>select o from Personal o</code> */
    public List<Personal> getPersonalFindAll() {
        return em.createNamedQuery("Personal.findAll").getResultList();
    }

    public InformacionKm persistInformacionKm(InformacionKm informacionKm) {
        em.persist(informacionKm);
        return informacionKm;
    }

    public InformacionKm mergeInformacionKm(InformacionKm informacionKm) {
        return em.merge(informacionKm);
    }

    public void removeInformacionKm(InformacionKm informacionKm) {
        informacionKm = em.find(InformacionKm.class, informacionKm.getIdInfoKm());
        em.remove(informacionKm);
    }

    /** <code>select o from InformacionKm o</code> */
    public List<InformacionKm> getInformacionKmFindAll() {
        return em.createNamedQuery("InformacionKm.findAll").getResultList();
    }

    public Especialista persistEspecialista(Especialista especialista) {
        em.persist(especialista);
        return especialista;
    }

    public Especialista mergeEspecialista(Especialista especialista) {
        return em.merge(especialista);
    }

    public void removeEspecialista(Especialista especialista) {
        especialista = em.find(Especialista.class, especialista.getRutEspecialista());
        em.remove(especialista);
    }

    /** <code>select o from Especialista o</code> */
    public List<Especialista> getEspecialistaFindAll() {
        return em.createNamedQuery("Especialista.findAll").getResultList();
    }

    public Mantencion persistMantencion(Mantencion mantencion) {
        em.persist(mantencion);
        return mantencion;
    }

    public Mantencion mergeMantencion(Mantencion mantencion) {
        return em.merge(mantencion);
    }

    public void removeMantencion(Mantencion mantencion) {
        mantencion = em.find(Mantencion.class, mantencion.getFolio());
        em.remove(mantencion);
    }

    /** <code>select o from Mantencion o</code> */
    public List<Mantencion> getMantencionFindAll() {
        return em.createNamedQuery("Mantencion.findAll").getResultList();
    }

    public Taller persistTaller(Taller taller) {
        em.persist(taller);
        return taller;
    }

    public Taller mergeTaller(Taller taller) {
        return em.merge(taller);
    }

    public void removeTaller(Taller taller) {
        taller = em.find(Taller.class, taller.getIdTaller());
        em.remove(taller);
    }

    /** <code>select o from Taller o</code> */
    public List<Taller> getTallerFindAll() {
        return em.createNamedQuery("Taller.findAll").getResultList();
    }
}
